import { selectDataClient } from '@/utils/common'
import { doChildren } from '@/api/turnover/utils.js'

import fn  from '@/utils/checkEmpty.js'

/**公共弹窗 ppw(公共弹窗简写) */
// 根据获取已选数据的ids
function createIds (detailedTableData, unique) {
    let ids = []
    if (!fn.checkEmpty(detailedTableData)) {
        detailedTableData[0].children.forEach(item => {
            if (item.changeType !== -1 ) {
                ids.push(item[unique])
            }
        })
    }
    return ids
}
// 根据id去重
function distinctById (detailedTableData, unique) {
    let itemObj = {}
    detailedTableData[0].children = detailedTableData[0].children.reduce((item, next)=>{
        if(next.changeType == -1 || next.oldState == -1) {
            item.push(next)
        }else{
            if(!itemObj[next[unique]]) {
                item.push(next)
                itemObj[next[unique]] = true
            }
        }
        return item
    }, [])
}
/**选择年计划 */
function selectYearPlan (planId, ids, type = 2) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/annualDemandPlan/introduceDtl', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id
            InitParamsStr: JSON.stringify(
                {
                    'planId': planId,
                    'type': type,  //什么类型的计划  引入的年计划 采购1 租赁2 临时：自购1/租赁2
                }
            ),    // 接口参数(name为模拟参数)
            Title: '选择年计划' // 标题
        }).then(val => {
            // const res = doChildren(val, 'demand', billId)
            resolve(val)
        })
    })
}
/**
 *选年计划二次封装
 * @param {*} detailedTableData 树结构
 * @param {*} annualDemandPlanBillId 年计划id
 * @param {*} billId 单据id
 * @param {*} type 引入的年计划 采购1 租赁2 临时：自购1/租赁2
 * @param {*} doChildrenType --momentNeedPlan（临时需用计划）leasePlan（租赁计划） procuremenPlan(采购计划)
 * @returns
 */
async function setYearPlanData (detailedTableData, annualDemandPlanBillId, billId, type = 2, doChildrenType) {

    console.log(detailedTableData, annualDemandPlanBillId, billId, type, doChildrenType)
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'annualDemandPlanDtlId')
        selectYearPlan(annualDemandPlanBillId, ids, type).then(data => {
            if (data.length > 0) {
                const obj = doChildren(data, doChildrenType, billId, doChildrenType == 'momentNeedPlan' ? type - 1 : type)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                // 根据id去重
                distinctById(detailedTableData, 'annualDemandPlanDtlId')

                resolve({ detailedTableData, data })
            }
        })

    })
}
// 租赁计划 选年计划
async function leasePlanSetYearPlanData (detailedTableData, annualDemandPlanBillId, billId, type, doChildrenType) {
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'annualDemandPlanDtlId')

        selectYearPlan(annualDemandPlanBillId, ids).then(data => {
            if(data.length > 0) {
                const obj = doChildren(data, doChildrenType, billId, type)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                // 根据id去重
                distinctById(detailedTableData, 'annualDemandPlanDtlId')

                resolve({ detailedTableData, data })
            }
        })

    })
}

/**物资基础库 */
function categoryLibrary (isCentralizedPurchasing = '') {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/material/categoryLibrary/queryListByParentClassId2', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            InitParamsStr: JSON.stringify(
                {
                    'parantiId': '0',
                    'topClassNameNeed': ['周转材料'],
                    'isCentralizedPurchasing': isCentralizedPurchasing //0普通 1集中

                }
            ),    // 接口参数(name为模拟参数)
            Title: '选择基础库' // 标题
        }).then(res => {
            res.forEach(v => {
                v.materialId = v.billId
                v.materialClassId = v.classIdPath
                v.materialClassName = v.classNamePath
            })
            resolve(res)
        })
    })
}
/**供方 */
function GeneralSelectOuter (type, businessTypes = [], businessUnitTypes = []) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: 'GeneralSelectOuter', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            Title: '选择供方', // 标题
            InitParamsStr: JSON.stringify({
                'businessTypes': businessTypes,
                'businessUnitTypes': businessUnitTypes,
                'keyword': '',
                'limit': 10,
                'orgId': '',
                'page': 1,
                'states': [],
                'subcontractorTypes': [],
                'supplierTypes': [],
                'type': type //	类型（0分包商 1供应商 2 往来单位 3 事实外包方） []
            },),

        }).then(val => {
            resolve(val[0])
        })
    })

}
/**选择人员弹窗 */
function selectName () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/hr/user/getUserUnderOrgPage', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            Title: '人员选择' // 标题
        }).then(val => {
            const obj = val[0]
            resolve(obj) //userName userId
        })
    })

}
/**选择仓库弹窗 */
function selectWarehouse (warehouseType = 0) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/material/stock/listUsableInventoryByOrgIdForSelect', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            Title: '人员仓库', // 标题
            InitParamsStr: warehouseType
        }).then(val => {
            const obj = val[0]
            resolve(obj) //userName userId
        })
    })

}

// 集采汇总选单位
function getAllOrgPage () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/hr/org/getAllOrgPage', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            Title: '选择机构' // 标题
        }).then(val => {
            resolve(val[0])
        })
    })
}

// 集采汇总 -- 选择采购方式弹窗 从字典
function selectPurchaseType () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/config/kv/getDicValue', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            InitParamsStr: JSON.stringify({
                type: 1,
                dicName: '总计划明细采购方式',
                dicKey: '',
            }),
            Title: '选择采购方式' // 标题
        }).then(res => {
            resolve(res[0])
        })
    })

}

/**选择本机构下级机构机构弹窗 */
function selectOrgRole () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/hr/org/getChildrenOrg', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            Title: '选择机构' // 标题
        }).then(val => {

            const obj = val[0]
            resolve(obj)
        })
    })
}
/**选择全部机构弹窗 */
function selectAllOrgRole () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/hr/org/getAllOrgPage', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            Title: '选择机构' // 标题
        }).then(val => {

            const obj = val[0]
            resolve(obj)
        })
    })
}
/**选择接入人 */
function selectgetUserUnderOrgPage (orgId) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/hr/user/getUserUnderOrgPage', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            InitParamsStr: JSON.stringify({ 'orgId': orgId }),    // 接口参数
            Title: '选择接入人' // 标题
        }).then(val => {
            const obj = val[0]
            resolve(obj)
        })
    })
}

/**选择年度需用计划--只要billid的那种--用于基本信息的调用 */
function introducePlan () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/annualDemandPlan/introducePlan', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id
            InitParamsStr: JSON.stringify(
                {
                    'keyWord': '',
                    'limit': 10,
                    'page': 1
                }

            ),
            Title: '引入年度计划' // 标题
        }).then(val => {
            const obj = val[0]
            resolve(obj)
        })
    })

}

/**入库 --明细--选物资 */
function TurnoverSelectInstockMaterials (businessType, ids, orgId) {
    console.log(ids)
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: 'TurnoverSelectInstockMaterials', // 客户端对应方法名
            IsSingleMode: false, // 是否单GeneralSelectOuter选 true 单选 false 多选
            SelectedIDs: ids || [], // 已选中id
            Title: '物资', // 标题
            InitParamsStr: JSON.stringify({
                'parentId': '0', //父级id
                'SelectMaterialsType': businessType,
                'orgId': orgId,
            }),    // 接口参数(name为模拟参数)
        }).then(val => {
            // 更具OrgId获取仓库信息

            resolve(val)
        })
    })
}
/**入库 --明细--二次封装 */
function setTurnoverSelectInstockMaterials (detailedTableData, billId, businessType, orgId, ) {
    return new Promise(resolve => {
        let ids = []
        ids = createIds(detailedTableData, 'sourceDtlId')
        console.log(ids)
        TurnoverSelectInstockMaterials(businessType, ids || [], orgId).then(data => {

            if (data.length > 0) {
                const obj = doChildren([...data], 'storage', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }

            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve({
                    data,
                    detailedTableData
                })
            }
        })

    })
}

/**领料、分包商退库的选择库存*/
function subcontract (businessTypeKey) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/subcontract/thirdParty/getSubReceiveZc', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            InitParamsStr: JSON.stringify({ 'contractType': businessTypeKey }),
            Title: '查询合同' // 标题
        }).then(val => {
            resolve(val[0])
        })
    })

}
/**领料&&退货 选择库存*/
function selectStock (type, ids) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/realTimeInventory/selectInventory', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids || [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            InitParamsStr: type + '', //退库1；领料2
            Title: '选择库存' // 标题
        }).then(val => {
            resolve(val)
        })
    })
}
/**领料选库存  二次封装 */
// doChildrenType 默认是领料   盘盈盘亏入相应的判断
async function setSelectStock (detailedTableData, billId, type, doChildrenType = 'receive') {
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'sourceDtlId')
        selectStock(type, ids).then(data => {
            if(data.length > 0) {
                const obj = doChildren(data, doChildrenType, billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve({ detailedTableData, data })
            }
        })

    })

}
/**分包商退库-选择合同 */
function returnSelectContract (type) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/receive/returnSelectContract', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            InitParamsStr: type + '',    // 接口参数(name为模拟参数)
            Title: '选择合同' // 标题
        }).then(val => {
            resolve(val[0])
        })
    })

}
/**分包商退库-库存 */
function receiveSelectInventory (contractId, parentId, ids) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/realTimeInventory/receiveSelectInventory', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            InitParamsStr: JSON.stringify({
                'contractId': contractId,
                'parentId': parentId
            }),    // 接口参数(name为模拟参数)
            Title: '选择合同' // 标题
        }).then(val => {
            resolve(val)
        })
    })

}
/**
 *闲置登记-选择库存二次封装
 */
async function setReceiveSelectInventory (detailedTableData, billId, contractId, parentId) {
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'sourceDtlId')
        receiveSelectInventory(contractId, parentId, ids).then(data => {
            if(data.length > 0) {
                const obj = doChildren(data, 'Outstock', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve({ detailedTableData, data })
            }
        })

    })

}
/**分页获取分包商乙方人员-人员信息(用于选择器)   选择退库人员*/
function personnelOfPartyB (subcontractorId ) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/material/personnelOfPartyB/listPersonnelInformationByFilter', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            InitParamsStr: JSON.stringify(subcontractorId),
            Title: '选择人员' // 标题
        }).then(val => {
            resolve(val[0])
        })
    })

}

/**闲置登记 调拨 -选择库存*/
/**
 *
 * @param {*} ids 回显的ids
 * @param {*} type 1：调拨 | 2：闲置
 * @returns
 */
function idleRegistrationSelectInventory (ids, type ) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/realTimeInventory/idleRegistrationSelectInventory', // 客户端对应方法名

            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            // 接口参数(name为模拟参数)
            InitParamsStr: JSON.stringify(type),
            Title: '选择闲置' // 标题
        }).then(val => {
            resolve(val)
        })
    })

}
/**
 *闲置登记 调拨 -选择库存二次封装
 */
async function setIdleRegistrationSelectInventory (detailedTableData, billId, type) {
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'sourceDtlId')
        idleRegistrationSelectInventory(ids, type).then(data => {

            if(data.length > 0) {
                const obj = doChildren(data, 'leisureCheck', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve(detailedTableData)
            }
        })

    })

}

/**内阻调动 选择明细*/
function internalLeaseselectIdleRegistration (ids) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/idleRegistration/internalLeaseselectIdleRegistration', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            // 接口参数(name为模拟参数)
            Title: '选择库存' // 标题
        }).then(val => {
            resolve(val)
        })
    })
}
/**内阻调动 二次封装*/
function setInternalLeaseselectIdleRegistration (detailedTableData, billId) {
    return new Promise(resolve => {
        // 回显的ids
        let arrIds = []

        if(!fn.checkEmpty(detailedTableData)) {
            detailedTableData[0].children.map(v => {
                if (v.changeType !== -1) {
                    let obj = {
                        materialClassId: detailedTableData[0].topClassId + '/' + v.materialClassId,
                        materialId: v.materialId,
                        spec: v.spec,
                        texture: v.texture
                    }
                    arrIds.push(JSON.stringify(obj))
                }

            })
        }

        internalLeaseselectIdleRegistration(arrIds).then(data => {
            if(data.length > 0) {
                const obj = doChildren(data, 'Idle', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }

            if (detailedTableData) {
                let itemObj = {}
                detailedTableData[0].children = detailedTableData[0].children.reduce((item, next)=>{
                    if(next.changeType == -1 || next.oldState == -1) {
                        item.push(next)
                    }else{
                        if(!itemObj[next.materialClassId] || !itemObj[next.materialId] || !itemObj[next.texture] || !itemObj[next.spec]) {
                            item.push(next)
                            itemObj[next.materialClassId] = true
                            itemObj[next.materialId] = true
                            itemObj[next.texture] = true
                            itemObj[next.spec] = true
                        }
                    }
                    return item
                }, [])
                resolve(detailedTableData)
            }
        })

    })

}

/**租赁退场 选择明细*/
function selectExitDtl (ids = []) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/warehousing/selectExitDtl', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            // 接口参数(name为模拟参数)
            InitParamsStr: '0',
            Title: '选择库存' // 标题
        }).then(val => {

            resolve(val)
        })
    })
}

/**
 *内租调动-选择库存二次封装
 */
async function setSelectExitDtl (detailedTableData, billId) {
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'sourceDtlId')
        selectExitDtl(ids).then(data => {
            const childData = data.filter(item=> item.isDetailed === 1)
            if(data.length > 0) {
                const obj = doChildren(childData, 'LeaseOut', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve({ detailedTableData, childData })
            }
        })

    })

}

/**盘点 选择明细*/
function selectInventoryDtl (contractId, subcontractorId, ids) {

    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/receive/selectInventoryDtl', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            // 接口参数(name为模拟参数)
            InitParamsStr: JSON.stringify({
                'contractId': contractId, //合同ID 必填
                'subcontractorId': subcontractorId, //分包商ID 必填
            }),
            Title: '选择库存' // 标题
        }).then(val => {
            resolve(val)
        })
    })
}
/**
 *盘点-选择库存二次封装
 */
async function setSelectInventoryDtl (detailedTableData, billId, contractId, subcontractorId) {
    return new Promise(resolve => {
        // 回显的ids
        const ids = createIds(detailedTableData, 'sourceDtlId')
        selectInventoryDtl(contractId, subcontractorId, ids).then(data => {

            if(data.length > 0) {
                const obj = doChildren(data, 'Inventory', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve(detailedTableData)
            }
        })

    })

}
/** 摊销--按数量*/
function selectQuantityAmortizations ( ) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/amortization/selectQuantityAmortizations', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            // 接口参数(name为模拟参数)
            InitParamsStr: '0',
            Title: '选择库存' // 标题
        }).then(val => {
            const data = val.filter(item=> item.isDetailed === 1) //只要最子级的数据
            resolve(data)
        })
    })
}
async function setSelectQuantityAmortizations (detailedTableData, billId) {
    return new Promise(resolve => {
        // 回显的ids
        // const ids = createIds(detailedTableData, 'sourceDtlId')
        selectQuantityAmortizations().then(data => {

            if(data.length > 0) {
                const obj = doChildren(data, 'amortizationQuanty', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve(detailedTableData)
            }
        })

    })
}
/** 摊销--按金额*/
function selectAmountAmortizations ( ) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/amortization/selectAmountAmortizations', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            // 接口参数(name为模拟参数)
            InitParamsStr: '0',
            Title: '选择库存' // 标题
        }).then(val => {
            const data = val.filter(item=> item.isDetailed === 1) //只要最子级的数据
            resolve(data)
        })
    })
}
async function setSelectAmountAmortizations (detailedTableData, billId) {
    return new Promise(resolve => {
        // 回显的ids
        // const ids = createIds(detailedTableData, 'sourceDtlId')
        selectAmountAmortizations().then(data => {

            if(data.length > 0) {
                const obj = doChildren(data, 'amortizationMoney', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve(detailedTableData)
            }
        })
    })
}

/**分包商退库-  摊销 */
function turnoverReceiveInventorySelectContract () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/receive/inventorySelectContract', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            Title: '选择分包商', // 标题
        }).then(val => {
            resolve(val)
        })
    })
}
function setTurnoverReceiveInventorySelectContract (detailedTableData, billId) {
    return new Promise(resolve => {
        turnoverReceiveInventorySelectContract().then(data => {
            data.forEach(item=>{
                item.subcontractorName = item.receiveCompanyName
                item.subcontractName = item.contractName
                item.subcontractType = item.contractType //合同类型
                item.subcontractNumber = item.contractNumber
                item.planAmount = item.contractAmount
                item.billId = billId
                item.subcontractorId = item.contractId
                item.changeType = 1
                item.apportionmentRatio = 0 //分摊比列
            })
            if(data.length > 0) {
                if (detailedTableData.length > 0) {
                    detailedTableData.push(...data)
                }else{
                    detailedTableData = data
                }
            }
            if (detailedTableData) {
                let itemObj = {}
                detailedTableData = detailedTableData.reduce((item, next)=>{
                    if(next.changeType == -1) {
                        item.push(next)
                    }else{
                        if(!itemObj[next['subcontractorId']]) {
                            item.push(next)
                            itemObj[next['subcontractorId']] = true
                        }
                    }
                    return item
                }, [])
                resolve(detailedTableData)
            }

        })
    })
}
/**摊销变更选择明细 */
function turnoverAcceptanceGetRatioChangeDtl () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/acceptance/getRatioChangeDtl', // 客户端对应方法名
            IsSingleMode: true, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            Title: '选择分包商', // 标题
            InitParamsStr: JSON.stringify({
                'orgId': '',
                'parentId': '0'
            }),    // 接口参数(name为模拟参数)
        }).then(val => {
            const data = val.filter(item=> item.isDetailed === 1) //只要最子级的数据
            resolve(data)
        })
    })
}
function setTurnoverAcceptanceGetRatioChangeDtl (detailedTableData, billId) {
    return new Promise(resolve => {
        // 回显的ids
        // const ids = createIds(detailedTableData, 'sourceDtlId')
        turnoverAcceptanceGetRatioChangeDtl().then(data => {

            if(data.length > 0) {
                const obj = doChildren(data, 'amortizationChange', billId)
                if (detailedTableData.length > 0) {
                    detailedTableData[0].children.push(...obj[0].children)
                }else{
                    detailedTableData = obj
                }
            }
            if (detailedTableData) {
                distinctById(detailedTableData, 'sourceDtlId')
                resolve(detailedTableData)
            }
        })
    })
}
/**摊销汇总 选周材摊销 */
function turnoverAmortizationGetAmortization () {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/amortization/getAmortization', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: [], // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            Title: '选择摊销', // 标题
        }).then(val => {
            if (val.length > 0) {
                const obj = {}
                obj.amortizationBill = val.map(item => {
                    return {
                        amortizationId: item.billId,
                        amortizationNo: item.billNo,
                        amortizationAmount: item.amount,
                        amortizationQuantity: item.quantity,
                        amortizationDate: item.amortizationDate,
                    }
                })
                // 金额
                obj.amount = val.reduce((total, cur)=>{
                    return total += cur.amount
                }, 0)
                //数量
                obj.quantity = val.reduce((total, cur)=>{
                    return total += cur.quantity
                }, 0)
                resolve(obj)
            }
        })
    })
}
/**建议租赁商 选计划明细 */
function turnoverLeasePlanGetPlanDtl (parantiId, ids = []) {
    return new Promise(resolve => {
        selectDataClient({
            SelectServiceToken: '/turnover/leasePlan/getPlanDtl', // 客户端对应方法名
            IsSingleMode: false, // 是否单选 true 单选 false 多选
            SelectedIDs: ids, // 已选中id(注意：是上一次已选中的id，不是要传的参数，如果第一次选，则传[])
            Title: '选择计划明细', // 标题
            InitParamsStr: parantiId
        }).then(val => {
            val.forEach(item => {
                item.sourceDtlId = item.dtlId
                item.dtlId = null
                item.billId = parantiId
                item.changeType = 1
            })
            resolve(val)
        })
    })
}
function setTurnoverLeasePlanGetPlanDtl (detailedTableData, billId) {
    return new Promise(resolve => {
        // 回显的ids
        let ids = []
        if (!fn.checkEmpty(detailedTableData)) {
            detailedTableData.forEach(item => {
                if (item.changeType !== -1 ) {
                    ids.push(item.dtlId)
                }
            })
        }
        turnoverLeasePlanGetPlanDtl(billId, ids).then(data => {
            if(data.length > 0) {
                if (detailedTableData.length > 0) {
                    detailedTableData.push(...data)
                }else{
                    detailedTableData = data
                }
            }
            if (detailedTableData) {
                let itemObj = {}
                detailedTableData = detailedTableData.reduce((item, next)=>{
                    if(next.changeType == -1) {
                        item.push(next)
                    }else{
                        if(!itemObj[next['sourceDtlId']]) {
                            item.push(next)
                            itemObj[next['sourceDtlId']] = true
                        }
                    }
                    return item
                }, [])
                resolve({ detailedTableData, data } )
            }
        })
    })
}
export {
    selectYearPlan,
    setYearPlanData,
    leasePlanSetYearPlanData, //租赁计划选年计划
    categoryLibrary, //物资基础库
    GeneralSelectOuter, //选择供方
    selectName, //选择人员弹窗
    selectWarehouse,
    getAllOrgPage, //集采汇总选单位
    selectPurchaseType,
    selectOrgRole, //选择机构
    selectAllOrgRole,
    selectgetUserUnderOrgPage, //选择机构下级人员
    introducePlan,
    TurnoverSelectInstockMaterials, //入库 选择物资
    setTurnoverSelectInstockMaterials,
    subcontract, //合同选领料单位
    selectStock, //选择库存
    setSelectStock, //二次封装
    returnSelectContract, //分包商退库选择合同
    receiveSelectInventory, //周材分包商退库选择库存
    setReceiveSelectInventory,
    personnelOfPartyB, //乙方人员
    idleRegistrationSelectInventory, //选择周材闲置
    setIdleRegistrationSelectInventory, //二次封装
    internalLeaseselectIdleRegistration, //内租调动 选择明细
    setInternalLeaseselectIdleRegistration, //内租调动 二次封装
    selectExitDtl, //租赁退场 选择明细
    setSelectExitDtl,
    selectInventoryDtl, //盘点 选择明细
    setSelectInventoryDtl,
    selectQuantityAmortizations, //摊销-按数量
    setSelectQuantityAmortizations, //摊销-按数量 二次封装
    selectAmountAmortizations, //摊销-按金额
    setSelectAmountAmortizations, //按金额 二次封装
    turnoverReceiveInventorySelectContract, // 摊销 --分包商
    setTurnoverReceiveInventorySelectContract, // 摊销 --分包商二次封装
    turnoverAcceptanceGetRatioChangeDtl, //摊销变更
    setTurnoverAcceptanceGetRatioChangeDtl,
    turnoverAmortizationGetAmortization, //摊销汇总 选周材摊销
    turnoverLeasePlanGetPlanDtl, //建议租赁商 选计划明细
    setTurnoverLeasePlanGetPlanDtl,
}